from redis import Redis, ConnectionPool


class Mredis():
    def __init__(self):
        # 创建 Redis 连接池，连接到本地 Redis 服务器，使用默认数据库 0
        self.pool = ConnectionPool(host='localhost', port=6379, db=0)
        # 使用连接池创建 Redis 客户端实例
        self.r = Redis(connection_pool=self.pool)
        # 另一种创建 Redis 客户端实例的方式，可直接指定主机和端口，此处被注释掉
        # self.r = Redis(host='124.71.227.70',port=6379)

    # 字符串操作：添加字符串值
    def set_str(self, key, value):
        # 调用 Redis 的 set 方法，将键值对存储到 Redis 中
        return self.r.set(key, value)

    # 字符串操作：添加带有过期时间的字符串值
    # times 单位为秒
    def setex_str(self, key, times, value):
        # 调用 Redis 的 setex 方法，存储键值对并设置过期时间
        return self.r.setex(key, times, value)

    # 字符串操作：仅当键不存在时添加字符串值
    def setnx_str(self, key, value):
        # 调用 Redis 的 setnx 方法，仅当键不存在时设置键值对
        return self.r.setnx(key, value)

    # 字符串操作：将键的值增加指定的值
    def str_incr(self, key, value):
        # 调用 Redis 的 incr 方法，将键的值增加指定的值
        return self.r.incr(key, value)

    # 字符串操作：获取键的值
    def get_str(self, key):
        # 调用 Redis 的 get 方法获取键的值
        value = self.r.get(key)
        if value:
            # 如果值存在，将字节数据解码为字符串
            value = value.decode()
        return value

    # 字符串操作：将键的值增加指定的计数
    def incr_str(self, key, count):
        # 调用 Redis 的 incr 方法，将键的值增加指定的计数
        return self.r.incr(key, count)

    # 字符串操作：将键的值减少指定的计数
    def decr_str(self, key, count):
        # 调用 Redis 的 decr 方法，将键的值减少指定的计数
        return self.r.decr(key, count)

    # 字符串操作：删除键
    def str_del(self, key):
        # 调用 Redis 的 delete 方法删除键
        return self.r.delete(key)

    # Hash 操作：向 Hash 中添加键值对
    def hash_add(self, key, field, value):
        # 调用 Redis 的 hset 方法，向 Hash 中添加键值对
        return self.r.hset(key, field, value)

    # Hash 操作：获取 Hash 的所有键值对
    def hash_getall(self, key):
        # 调用 Redis 的 hgetall 方法，获取 Hash 的所有键值对
        return self.r.hgetall(key)

    # Hash 操作：获取 Hash 中指定字段的值
    def hash_getone(self, key, field):
        # 调用 Redis 的 hget 方法，获取 Hash 中指定字段的值
        return self.r.hget(key, field)

    # Hash 操作：删除 Hash 中指定字段
    def hash_hdel(self, key, field):
        # 调用 Redis 的 hdel 方法，删除 Hash 中指定字段
        return self.r.hdel(key, field)

    # 键操作：根据模式模糊查询键
    def get_key(self, key):
        # 调用 Redis 的 keys 方法，根据模式模糊查询键
        return self.r.keys(key)

    # List 操作：向 List 左侧添加元素
    def list_push(self, key, value):
        # 调用 Redis 的 lpush 方法，向 List 左侧添加元素
        return self.r.lpush(key, value)

    # List 操作：从 List 右侧弹出元素
    def list_pop(self, key):
        # 调用 Redis 的 rpop 方法，从 List 右侧弹出元素
        return self.r.rpop(key)

    # List 操作：获取 List 中指定范围的元素
    def list_lrange(self, key, min, max):
        # 调用 Redis 的 lrange 方法，获取 List 中指定范围的元素
        return self.r.lrange(key, min, max)

    # List 操作：获取 List 的长度
    def list_len(self, key):
        # 调用 Redis 的 llen 方法，获取 List 的长度
        return self.r.llen(key)

    # List 操作：从 List 中删除指定元素
    def list_del(self, key, field):
        # 调用 Redis 的 lrem 方法，从 List 中删除指定元素
        return self.r.lrem(key, -1, field)

    # List 操作：将元素从一个 List 右侧弹出并添加到另一个 List 的左侧
    def list_rpoplpush(self, list1, list2):
        # 调用 Redis 的 rpoplpush 方法，将元素从一个 List 右侧弹出并添加到另一个 List 的左侧
        return self.r.rpoplpush(list1, list2)

    # ZSet 操作：向 ZSet 中添加元素及分数
    def zset_zadd(self, key, score, value):
        # 创建一个映射，将元素映射到分数
        map = {value: score}
        # 调用 Redis 的 zadd 方法，向 ZSet 中添加元素及分数
        return self.r.zadd(key, mapping=map)

    # ZSet 操作：从 ZSet 中删除元素
    def zset_zrem(self, key, value):
        # 调用 Redis 的 zrem 方法，从 ZSet 中删除元素
        return self.r.zrem(key, value)

    # ZSet 操作：根据分数范围获取元素
    def zset_zrangebyscore(self, key, min, max):
        # 调用 Redis 的 zrangebyscore 方法，根据分数范围获取元素
        return self.r.zrangebyscore(key, min, max)


r = Mredis()